home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 November: Tool Chest / Dev.CD Nov 00 TC Disk 2.toast / pc / sample code / sound / sndplaydoublebuffer / _source / wave.c < prev   
Encoding:
C/C++ Source or Header  |  2000-09-28  |  6.8 KB  |  223 lines
  1. /*
  2.     File:        WAVE.c
  3.  
  4.     Contains:    Routines demonstrating how to parse Microsoft's WAVE sound files.
  5.  
  6.     Written by: Mark Cookson    
  7.  
  8.     Copyright:    Copyright ©1996-1999 by Apple Computer, Inc., All Rights Reserved.
  9.  
  10.                 You may incorporate this Apple sample source code into your program(s) without
  11.                 restriction. This Apple sample source code has been provided "AS IS" and the
  12.                 responsibility for its operation is yours. You are not permitted to redistribute
  13.                 this Apple sample source code as "Apple sample source code" after having made
  14.                 changes. If you're going to re-distribute the source, we require that you make
  15.                 it clear in the source that the code was descended from Apple sample source
  16.                 code, but that you've made changes.
  17.  
  18.     Change History (most recent first):
  19.                 8/31/1999    Karl Groethe    Updated for Metrowerks Codewarror Pro 2.1
  20.                 
  21.  
  22. */
  23. #include "WAVE.h"
  24.  
  25. /* Please note that this code was written in less than 6 hours, does very little error checking
  26.    and probably will not work for all files.  I have tested it with the WAVE files at my
  27.    disposal and it worked with them.  Your milage may vary.
  28.  
  29.    I do know that it will probably be impossible to get the Mac's IMA decompressor to
  30.    decompress IMA (and ADPCM) compressed WAVE files because the Mac's IMA has a different
  31.    file format from the WAVE file and the decompressor cannot correctly decompress WAVE files.
  32.  
  33.    The Mac IMA compressed file has predictor bytes in the data stream that the WAVE files
  34.    do not have.
  35. */
  36.  
  37. /* Given an WAVE File gets the sample rate and other relavent pieces of information.
  38.    This has been modified from its orignal form found in the Develop 11 MultiBuffer source. */
  39. /*-----------------------------------------------------------------------*/
  40.         OSErr    ASoundGetWAVEHeader        (SoundInfoPtr theSoundInfo,
  41.                                         long *dataStart,
  42.                                         long *length)
  43. /*-----------------------------------------------------------------------*/
  44. {
  45.     WAVETemplatePtr            WAVETemplate;                    /* ...for ease of access */
  46.     long                    filePosition        = kInit,
  47.                             byteCount            = kInit;
  48.     short                    format                = kInit;
  49.     unsigned short            chunkFlags            = kInit;    /* remember chunks we've seen */
  50.     OSErr                    err                    = noErr;
  51.     char                    chunkBuffer[kWAVEChunkBufferSize];
  52.  
  53.     *dataStart = kInit;
  54.  
  55.     /*  Now for the fun part!  We're going to assume that these are generic, non-compressed
  56.             WAVE files and parse accordingly... */
  57.  
  58.     do {
  59.         /*    Position ourselves at the beginning of the next chunk and read in
  60.             a hunk-o-data... */
  61.         err = SetFPos (theSoundInfo->refNum, fsFromStart, filePosition);
  62.         if (err != noErr) {
  63.             DebugPrint ("\pSetFPos failed!");
  64.             break;
  65.         }
  66.  
  67.         byteCount = kWAVEChunkBufferSize;
  68.         err = FSRead (theSoundInfo->refNum, &byteCount, chunkBuffer);                                                /* read a chunk */
  69.         if ((err != noErr) && (err != eofErr)) {
  70.             DebugPrint ("\pFSRead failed!");
  71.             break;
  72.         }
  73.  
  74.         /*    Now, position the template over the data... */
  75.         WAVETemplate = (WAVETemplatePtr) chunkBuffer;
  76.  
  77.         /* assume a failure and break out of the do {} while loop if the next case isn't found.
  78.            if the case is found and no other error is detected, then each case needs to set noErr */
  79.         err = kBadWAVEFileFormat;                                
  80.         switch (WAVETemplate->generic.ckID) {
  81.             case WAVEFORMID:
  82.                 chunkFlags |= kWAVEFORMID;                                                                /* otherwise mark it found */
  83.                 filePosition += 12;
  84.                 err = noErr;
  85.                 break;
  86.             case FormatID:
  87.                 chunkFlags |= kFormatID;                                                                /* otherwise mark it found */
  88.                 format = SwapShort (WAVETemplate->fmt.wFormatTag);
  89.                 theSoundInfo->needsMasking = false;
  90.                 switch (format) {
  91.                     case WAVE_FORMAT_PCM:
  92.                         err = SetupDBHeader (theSoundInfo,
  93.                                             SwapLong (WAVETemplate->fmt.dwSamplesPerSec),
  94.                                             ((SwapShort (WAVETemplate->fmt.wBlockAlign) / SwapShort (WAVETemplate->fmt.wChannels)) * 8),
  95.                                             SwapShort (WAVETemplate->fmt.wChannels),
  96.                                             notCompressed,
  97.                                             NoneType);
  98.                         break;
  99.                     case WAVE_FORMAT_MULAW:
  100.                     case IBM_FORMAT_MULAW:
  101.                         err = SetupDBHeader (theSoundInfo,
  102.                                             SwapLong (WAVETemplate->fmt.dwSamplesPerSec),
  103.                                             ((SwapShort (WAVETemplate->fmt.wBlockAlign) / SwapShort (WAVETemplate->fmt.wChannels)) * 8),
  104.                                             SwapShort (WAVETemplate->fmt.wChannels),
  105.                                             fixedCompression,
  106.                                             kULawCompression);
  107.                         filePosition += 2;    /* This is here because the only µlaw compressed file I ever saw needed it. */
  108.                         break;
  109.                     default:
  110.                         DebugPrint ("\pCan't deal with this file format");
  111.                         err = kUnknownFormat;
  112.                         break;
  113.                 }
  114.                 filePosition += 24;
  115.                 break;
  116.             case WAVEDataID:
  117.                 chunkFlags |= kWAVEDataID;
  118.                 *length = ReverseLong (WAVETemplate->waveData.ckSize);
  119.                 filePosition += 8;
  120.                 *dataStart = filePosition;
  121.                 err = noErr;
  122.                 break;
  123.             /* We don't care about any of these, and my handling of them is probably not correct */
  124.             case WAVEID:
  125.                 err = noErr;
  126.                 filePosition += 4;
  127.                 break;
  128.             case WAVEListID:
  129.                 err = noErr;
  130.                 filePosition += 4;
  131.                 break;
  132.             case SilenceID:
  133.                 err = noErr;
  134.                 filePosition += 4;
  135.                 break;
  136.             case CueID:
  137.                 err = noErr;
  138.                 filePosition += 24;
  139.                 break;
  140.             case FactID:
  141.                 err = noErr;
  142.                 filePosition += 4;
  143.                 break;
  144.             case PlaylistID:
  145.                 err = noErr;
  146.                 filePosition += 12;
  147.                 break;
  148.             case AssocDataID:
  149.                 err = noErr;
  150.                 filePosition += 32;
  151.                 break;
  152.             case LabelID:
  153.                 err = noErr;
  154.                 filePosition += 4;
  155.                 break;
  156.             case NoteID:
  157.                 err = noErr;
  158.                 filePosition += 4;
  159.                 break;
  160.             case TextWithLenID:
  161.                 err = noErr;
  162.                 filePosition += 16;
  163.                 break;
  164.             case EmbededFileID:
  165.                 err = noErr;
  166.                 filePosition += 8;
  167.                 break;
  168.             default:
  169.                 //DebugPrint ("\pSaw a field we didn't know about, this doesn't have to be bad");
  170.                 /* Start walking through the file looking for an ID we know about.
  171.                    This could get ugly, but what the heck... */
  172.                 filePosition += 1;
  173.                 err = noErr;
  174.                 break;
  175.         }
  176.     } while (stillMoreDataWAVEToRead);
  177.  
  178.     if (err != noErr) {
  179.         DebugPrint ("\pError in ASoundGetWAVEHeader");
  180.     }
  181.  
  182.     return err;
  183. }
  184.  
  185. /* These are here for the endian conversion required to parse the header.
  186.    The endian conversion used when playing a WAVE file is much better, don't worry.
  187.  */
  188. short SwapShort (const short theShort) {
  189.     char    tempChar    = kInit;
  190.     short    newShort    = kInit;
  191.  
  192.     tempChar = ((char *)&theShort)[0];
  193.     ((char *)&newShort)[0] = ((char *)&theShort)[1];
  194.     ((char *)&newShort)[1] = tempChar;
  195.  
  196.     return newShort;
  197. }
  198.  
  199. long SwapLong (const long theLong) {
  200.     short    tempShort    = kInit;
  201.     long    newLong        = kInit;
  202.  
  203.     tempShort = SwapShort (((short *)&theLong)[0]);
  204.     ((short *)&newLong)[0] = tempShort;
  205.     tempShort = SwapShort (((short *)&theLong)[1]);
  206.     ((short *)&newLong)[1] = tempShort;
  207.  
  208.     return newLong;
  209. }
  210.  
  211. long ReverseLong (const long theLong) {
  212.     char    tempChar    = kInit,
  213.             i            = kInit;
  214.     long    newLong        = kInit;
  215.  
  216.     for (i = nil; i < 2; i++) {
  217.         tempChar = ((char *)&theLong)[i];
  218.         ((char *)&newLong)[i] = ((char *)&theLong)[3-i];
  219.         ((char *)&newLong)[3-i] = tempChar;
  220.     }
  221.  
  222.     return newLong;
  223. }